home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Mac Game Programming Gurus / TricksOfTheMacGameProgrammingGurus.iso / More Source / C⁄C++ / graph3D / graph3D source / g3D_EvalCylind.c < prev    next >
Text File  |  1993-09-17  |  4KB  |  227 lines
  1. /*
  2.     Copyright '89    Christopher Moll
  3.     all rights reserved
  4. */
  5.  
  6.  
  7. #include    "graph3D.h"
  8.  
  9. extern    Boolean    useMainFunc;
  10.  
  11. extern    Real        *funcResults;
  12. extern    Vector        *scalVectResults;
  13. extern    Point        *graphPoints;    /* same elements as funcResults */
  14.  
  15. extern    Boolean        invldFormla;
  16.  
  17. extern    Boolean        functCurrent;
  18. extern    Boolean        vectrsCurrent;
  19.  
  20. extern    Boolean        noRedrawGrph;
  21.  
  22. extern    Vector        maxVect, minVect;
  23. extern    Real        rotMatrx[3][3];
  24.  
  25. extern    Boolean        inMultiFndr;
  26.  
  27. Real    startR, startT;
  28. Real    endR, endT;
  29. Real    deltaR, deltaT;
  30. int        numR, numT;
  31.  
  32.  
  33. EvalCylindFunct()
  34. {
  35.     Boolean    AllocateCylndPts();
  36.  
  37.     invldFormla = FALSE;
  38.     noRedrawGrph = TRUE;
  39.  
  40.     LoadFunction();
  41.  
  42.     if (invldFormla)    /* already gave warning message */
  43.         return;
  44.  
  45.     GetSpecDCont();
  46.  
  47.     deltaR = (endR - startR) / (numR - 1);
  48.     deltaT = (endT - startT) / (numT - 1);
  49.  
  50.     if (NOT(AllocateCylndPts()))
  51.         return;
  52.  
  53.     StoreCylindFunct();
  54.  
  55.     vectrsCurrent = FALSE;
  56.     functCurrent = TRUE;
  57.     noRedrawGrph = FALSE;
  58. }
  59.  
  60. static
  61. Boolean
  62. AllocateCylndPts()
  63. {
  64.     if (funcResults NEQ NIL)
  65.         free(funcResults);
  66.     if (scalVectResults NEQ NIL)
  67.         free((void *)scalVectResults);
  68.     if (graphPoints NEQ NIL)
  69.         free((void *)graphPoints);
  70.     funcResults = (Real *)NewPtr((long)sizeof(Real) * (long)numR * numT);
  71.     if (MemErr)
  72.         return(FALSE);
  73.     scalVectResults = (Vector *)NewPtr((long)sizeof(Vector) * (long)numR * numT);
  74.     if (MemErr)
  75.         return(FALSE);
  76.     graphPoints = (Point *)NewPtr((long)sizeof(Point) * (long)numR * numT);
  77.     if (MemErr)
  78.         return(FALSE);
  79.  
  80.     return(TRUE);
  81. }
  82.  
  83. static
  84. StoreCylindFunct()
  85. {
  86.     register    int    rCnt, tCnt;
  87.     Real        currR, currT;
  88.     Real        maxFunc, minFunc, funcVal;
  89.     Real        rAtMax, tAtMax;
  90.     Real        rAtMin, tAtMin;
  91.     Real        TheFunction();
  92.     Boolean        CmndPeriod();
  93.     
  94.     ShowMeter((long)numR * numT);
  95.  
  96.     useMainFunc = TRUE;
  97.     funcVal = TheFunction(startR, startT);
  98.     maxFunc = funcVal;
  99.     minFunc = funcVal;
  100.     rAtMax = startR;
  101.     tAtMax = startT;
  102.     rAtMin = startR;
  103.     tAtMin = startT;
  104.  
  105.     currR = startR;
  106.     for (rCnt = 0; rCnt < numR; rCnt++)
  107.     {
  108.         currT = startT;
  109.         for (tCnt = 0; tCnt < numT; tCnt++)
  110.         {
  111.             funcVal = TheFunction(currR, currT);
  112.             DisplayMeter();
  113.             funcResults[rCnt * numT + tCnt] = funcVal;
  114.             if (funcVal > maxFunc)
  115.             {
  116.                 maxFunc = funcVal;
  117.                 rAtMax = currR;
  118.                 tAtMax = currT;
  119.             }
  120.             else if (funcVal < minFunc)
  121.             {
  122.                 minFunc = funcVal;
  123.                 rAtMin = currR;
  124.                 tAtMin = currT;
  125.             }
  126.             currT += deltaT;
  127.         }
  128.         if (CmndPeriod())
  129.             break;  /* for */
  130.         currR += deltaR;
  131.     }
  132.  
  133. done:
  134.     maxVect.x = rAtMax * cos(tAtMax);
  135.     maxVect.y = rAtMax * sin(tAtMax);
  136.     maxVect.z = maxFunc;
  137.  
  138.     minVect.x = rAtMin * cos(tAtMin);
  139.     minVect.y = rAtMin * sin(tAtMin);
  140.     minVect.z = minFunc;
  141.  
  142.     RemoveMeter();
  143. }
  144.  
  145.  
  146.  
  147. SetCylindVectrs()
  148. {
  149. register    int    rCnt, tCnt;
  150. register    long    offSet;
  151.     Real        ImposLimits();
  152. register    Real        rValue, tValue;
  153. register    Vector        *scalePtr;
  154.     Real    SdeltaR;
  155. register    Real    SdeltaT;
  156.     Vector    pntVect;
  157.  
  158.     SdeltaR = deltaR;
  159.     SdeltaT = deltaT;
  160.  
  161.     scalePtr = scalVectResults;
  162.  
  163.     rValue = startR;
  164.  
  165.     for (rCnt = 0; rCnt < numR; rCnt++)
  166.     {
  167.         tValue = startT;
  168.         for (tCnt = 0; tCnt < numT; tCnt++)
  169.         {
  170.             offSet = (long)rCnt * (long)numT + tCnt;
  171.             pntVect.x = rValue * cos(tValue);
  172.             pntVect.y = rValue * sin(tValue);
  173.             pntVect.z = (ImposLimits(funcResults[offSet]));
  174.             MatrxMul(rotMatrx, &pntVect, scalePtr++);
  175.             tValue += SdeltaT;
  176.         }
  177.         rValue += SdeltaR;
  178.     }
  179.  
  180.     vectrsCurrent = TRUE;
  181. }
  182.  
  183.  
  184.  
  185. /*--------------------------------------------------------------------------------*/
  186.  
  187.  
  188.  
  189.  
  190.  
  191.  
  192. __SetCylindVectrs()
  193. {
  194. register    int    rCnt, tCnt;
  195. register    long    offSet;
  196.     Real        ImposLimits();
  197. register    Real        rValue, tValue;
  198. register    Vector        *scalePtr;
  199.     Real    SdeltaR;
  200. register    Real    SdeltaT;
  201.     Vector    pntVect;
  202.  
  203.     SdeltaR = deltaR;
  204.     SdeltaT = deltaT;
  205.  
  206.     scalePtr = scalVectResults;
  207.  
  208.     rValue = startR;
  209.  
  210.     for (rCnt = 0; rCnt < numR; rCnt++)
  211.     {
  212.         tValue = startT;
  213.         for (tCnt = 0; tCnt < numT; tCnt++)
  214.         {
  215.             offSet = (long)rCnt * (long)numT + tCnt;
  216.             pntVect.x = ImposLimits(rValue*tValue);
  217.             pntVect.y = ImposLimits(sin(tValue)+cos(rValue));
  218.             pntVect.z = ImposLimits(cos(rValue));
  219.             MatrxMul(rotMatrx, &pntVect, scalePtr++);
  220.             tValue += SdeltaT;
  221.         }
  222.         rValue += SdeltaR;
  223.     }
  224.  
  225.     vectrsCurrent = TRUE;
  226. }
  227.